package cn.zyq.charging.order.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.context.annotation.Bean;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Configuration;

import java.util.HashMap;
import java.util.Map;

/**
 * rabbit-mq配置类
 * 连接信息  用户名  密码
 * 定义 队列  交换机  并且绑定
 */
@Configuration
public class RabbitMQConfiguration {
    //正常订单队列的交换机
    public static final String ORDER_EXCHANGE_NAME_DIRECT = "order.exchange_direct";
    //正常订单队列的routingKey
    public static final String ORDER_ROUTING_KEY = "order.routing.key";
    //正常订单队列的name
    public static final String OrderQUEUE_NAME_DIRECT = "order.queue";

    /**定义正常订单的队列*/
    @Bean
    public Queue orderQueue(){
        //为这个正常的业务队列设置死信交换机的name和死信队列的RoutingKey
        Map<String, Object> args = new HashMap<String, Object>();
        args.put("x-dead-letter-exchange", ORDER_DEAD_LETTER_EXCHANGE_NAME);
        args.put("x-dead-letter-routing-key",ORDER_DEAD_LETTER_ROUTING_KEY);
        //模拟充电充满需要 2分钟  2*60*1000
        //Integer ttl =  2 * 60 * 1000;
        Integer ttl =  4 * 60 * 1000;//模拟充电时间最长4分钟(实际充电的最大时长可以是慢充8小时，快充1小时)
        //指定消息的存活时间
        args.put("x-message-ttl", ttl);
        //惰性队列,在消息很多的时候,存储到磁盘,避免消息积压,占用内存
        args.put("x-queue-mode", "lazy");
        //队列的消息进行持久化 保证队列中的消息不丢失
        Boolean durable  = true;
        //exclusive: 表示是否独占队列(默认是false，false就是多个消费者可以监听同一个队列)。
        //(exclusive=true表示一个消费者只能消费一个队列的消息<队列被消费者独有>)
        //autoDelete: 表示是否自动删除队列(默认是false，如果是true就是队列没有消费者时，自动删除此队列)。
        return new Queue(OrderQUEUE_NAME_DIRECT,durable,true,false,args);
    }

    /**定义正常队列的交换机*/
    @Bean
    public DirectExchange orderExchangeDirect(){
        return  new DirectExchange(ORDER_EXCHANGE_NAME_DIRECT);
    }

    /**
     * 把订单队列绑定到订单交换机
     */
    @Bean
    public Binding orderBinding(){
        return BindingBuilder.bind(orderQueue()).to(orderExchangeDirect()).with(ORDER_ROUTING_KEY);
    }





    //定义死信队列的信息
    //异常订单队列的交换机
    public static final String ORDER_DEAD_LETTER_EXCHANGE_NAME = "order.dead.letter.exchange";
    //异常订单队列的routingKey
    public static final String ORDER_DEAD_LETTER_ROUTING_KEY = "order.dead.letter.routing.key";
    //异常订单队列的name
    public static final String Order_DEAD_LETTER_QUEUE_NAME_DIRECT = "order.dead.letter.queue_direct";

    /**定义异常订单的死信队列*/
    @Bean
    public Queue deadLetterQueue(){
        return new Queue(Order_DEAD_LETTER_QUEUE_NAME_DIRECT,true,false,false);
    }

    /**定义异常订单的死信队列的交换机*/
    @Bean
    public DirectExchange deadLetterExchange(){
        return  new DirectExchange(ORDER_DEAD_LETTER_EXCHANGE_NAME,true,false);
    }

    /**
     * 将异常订单的死信队列和死信交换机进行绑定
     */
    @Bean
    public Binding deadLetterBindingDeadLetter(){
        return BindingBuilder.bind(deadLetterQueue())     .to(deadLetterExchange())     .with(ORDER_DEAD_LETTER_ROUTING_KEY);
    }

}



















